package com.yanqu.road.logic.pb;

import com.yanqu.road.entity.activity.douluodalu.DouLuoDaLuPatronsBattle;
import com.yanqu.road.entity.activity.douluodalu.DouLuoDaLuPatronsBattleEnemy;
import com.yanqu.road.entity.activity.douluodalu.DouLuoDaLuUserPatrons;
import com.yanqu.road.entity.activity.douluodalu.config.DouLuoDaLuConfig;
import com.yanqu.road.entity.activity.douluodalu.config.DouLuoDaLuEventInfo;
import com.yanqu.road.entity.activity.douluodalu.config.DouLuoDaLuRegionInfo;
import com.yanqu.road.entity.activity.douluodalu.data.DouLuoDaLuPatronsTimesData;
import com.yanqu.road.entity.activity.douluodalu.log.*;
import com.yanqu.road.pb.activity.douluodalu.DouLuoDaLuProto;
import com.yanqu.road.utils.string.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class DouLuoDaLuPb {

    public static DouLuoDaLuProto.DouLuoDaLuConfigSyncMsg.Builder buildDouLuoDaLuConfigSyncMsg(String language, DouLuoDaLuConfig config){
        DouLuoDaLuProto.DouLuoDaLuConfigSyncMsg.Builder builder = DouLuoDaLuProto.DouLuoDaLuConfigSyncMsg.newBuilder();
        if(config != null){
            for (DouLuoDaLuRegionInfo regionInfo : config.getRegionInfoList()) {
                builder.addRegion(parseDouLuoDaLuRegionInfoTemp(regionInfo, language));
            }
            for (DouLuoDaLuEventInfo daLuEventInfo : config.getEventInfoList()) {
                builder.addEvent(parseDouLuoDaLuEventInfoTemp(daLuEventInfo, language));
            }
        }
        return builder;
    }

    public static DouLuoDaLuProto.DouLuoDaLuEventInfoTemp.Builder parseDouLuoDaLuEventInfoTemp(DouLuoDaLuEventInfo eventInfo, String language){
        DouLuoDaLuProto.DouLuoDaLuEventInfoTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuEventInfoTemp.newBuilder();
        builder.setEventId(eventInfo.getEventId());
        builder.setEventType(eventInfo.getEventType());
        builder.setParam(eventInfo.getParam());
        builder.setRewards(eventInfo.getRewards());
        builder.setScore(eventInfo.getScore());
        builder.setTargetId(eventInfo.getTargetId());
        return builder;
    }

    public static DouLuoDaLuProto.DouLuoDaLuRegionInfoTemp.Builder parseDouLuoDaLuRegionInfoTemp(DouLuoDaLuRegionInfo regionInfo, String language){
        DouLuoDaLuProto.DouLuoDaLuRegionInfoTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuRegionInfoTemp.newBuilder();
        builder.setRegionId(regionInfo.getRegionId());
        builder.setEnergy(regionInfo.getEnergy());
        builder.setRingId(regionInfo.getRingId());
        builder.addAllConsumeCondition(regionInfo.getUpgradeConsumeList());
        builder.addAllEventIdList(regionInfo.getEventIdList());
        builder.addAllEventWeightList(regionInfo.getEventWeightList());
        builder.setScoreBase(regionInfo.getScoreBase());
        return builder;
    }

    public static DouLuoDaLuEventDefendData paresDouLuoDaLuEventDefendData(DouLuoDaLuProto.DouLuoDaLuEventBattleNotifyTemp notifyTemp, long userId, int activityId) {
        DouLuoDaLuEventDefendData defendData = new DouLuoDaLuEventDefendData();
        defendData.setActivityId(activityId);
        defendData.setUserId(userId);
        defendData.setEnemyUserId(notifyTemp.getEnemyUserId());
        defendData.setEnemyBaseInfo(PlayerBasePb.parseToUserBaseInfo(notifyTemp.getPlayerInfo()));
        defendData.setDamage(notifyTemp.getDamage());
        defendData.setBlood(notifyTemp.getBlood());
        defendData.setType(notifyTemp.getType());
        defendData.setLose(notifyTemp.getLose());
        defendData.setLogTime(System.currentTimeMillis());
        return defendData;
    }

    public static DouLuoDaLuProto.DouLuoDaLuEventBattleNotifyTemp.Builder builderDouLuoDaLuEventDefendData(DouLuoDaLuEventDefendData defendData) {
        DouLuoDaLuProto.DouLuoDaLuEventBattleNotifyTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuEventBattleNotifyTemp.newBuilder();
        builder.setUserId(defendData.getUserId());
        builder.setEnemyUserId(defendData.getEnemyUserId());
        if(defendData.getEnemyBaseInfo() != null) {
            builder.setPlayerInfo(PlayerBasePb.parsePlayerBaseTempMsg(defendData.getEnemyBaseInfo()));
        }
        builder.setDamage(defendData.getDamage());
        builder.setBlood(defendData.getBlood());
        builder.setType(defendData.getType());
        builder.setLose(defendData.getLose());
        builder.setLogTime(defendData.getLogTime());
        if(defendData.getFriendBaseInfo() != null){
            builder.setFriend(PlayerBasePb.parsePlayerBaseTempMsg(defendData.getFriendBaseInfo()));
        }
        builder.setEventType(defendData.getEventType());
        builder.setRewards(defendData.getRewards());
        builder.setConsume(defendData.getConsume());
        builder.setMonsterId(defendData.getMonsterId());
        builder.addAllParams(defendData.getParamList());
        builder.setEventId(defendData.getEventId());
        if(defendData.getEventId() > 0){
            builder.setType(defendData.getAttackType());
        }
        return builder;
    }

    public static DouLuoDaLuProto.DouLuoDaLuBattleReportTemp.Builder builderDouLuoDaLuBattleReportData(DouLuoDaLuBattleReportData reportData) {
        DouLuoDaLuProto.DouLuoDaLuBattleReportTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuBattleReportTemp.newBuilder();
        builder.setEnemyInfo(PlayerBasePb.parsePlayerBaseTempMsg(reportData.getEnemyBaseInfo()));
        builder.setUserId(reportData.getUserId());
        builder.setEnemyId(reportData.getEnemyId());
        builder.setPatronsId(reportData.getPatronsId());
        builder.setScore(reportData.getScore());
        builder.setPatronsNum(reportData.getPatronsNum());
        builder.setLogTime(reportData.getLogTime());
        builder.setBattleType(reportData.getBattleType());
        return builder;
    }

    public static List<DouLuoDaLuProto.DouLuoDaLuGetPatronsTimesTemp> parsePatronsTemList(Map<Integer, DouLuoDaLuPatronsTimesData> patronsTimesDataMap){
        List<DouLuoDaLuProto.DouLuoDaLuGetPatronsTimesTemp> list = new ArrayList<>();
        for (Map.Entry<Integer, DouLuoDaLuPatronsTimesData> entry : patronsTimesDataMap.entrySet()) {
            DouLuoDaLuProto.DouLuoDaLuGetPatronsTimesTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuGetPatronsTimesTemp.newBuilder();
            DouLuoDaLuPatronsTimesData data = entry.getValue();
            builder.setPatronsId(data.getPatronsId());
            builder.setSendTimes(data.getSendTimes());
            builder.setFightTimes(data.getFightTimes());
            builder.setZhuiBuTimes(data.getZhuiBuTimes());
            list.add(builder.build());
        }
        return list;
    }

    public static DouLuoDaLuPatronsBattle parseDouLuoDaLuPatronsBattle(DouLuoDaLuProto.DouLuoDaLuPatronsBattleDataTemp patronsBattleDataTemp){
        DouLuoDaLuPatronsBattle patronsBattle = new DouLuoDaLuPatronsBattle();
        patronsBattle.setPatronsId(patronsBattleDataTemp.getPatronsId());
        patronsBattle.setAbility(patronsBattleDataTemp.getAbility());
        patronsBattle.setHunLi(patronsBattleDataTemp.getHunLi());
        patronsBattle.setTotalBlood(patronsBattleDataTemp.getTotalBlood());
        patronsBattle.setBlood(patronsBattleDataTemp.getBlood());

        if(patronsBattleDataTemp.hasWinTimes()){
            patronsBattle.setTimes(patronsBattleDataTemp.getWinTimes());
        }
        patronsBattle.setWinRewards(patronsBattleDataTemp.getRewards());
        if(patronsBattleDataTemp.hasBuyBuffIdx()){
            patronsBattle.setBuyBuffIdx(patronsBattleDataTemp.getBuyBuffIdx());
        }
        patronsBattle.getBuffList().addAll(patronsBattleDataTemp.getBuffList());
        return patronsBattle;
    }

    public static DouLuoDaLuPatronsBattleEnemy parseDouLuoDaLuPatronsBattleEnemy(DouLuoDaLuProto.DouLuoDaLuPatronsBattleDataTemp patronsBattleDataTemp){
        DouLuoDaLuPatronsBattleEnemy patronsBattle = new DouLuoDaLuPatronsBattleEnemy();
        patronsBattle.setPatronsId(patronsBattleDataTemp.getPatronsId());
        patronsBattle.setAbility(patronsBattleDataTemp.getAbility());
        patronsBattle.setTotalBlood(patronsBattleDataTemp.getTotalBlood());
        patronsBattle.setBlood(patronsBattleDataTemp.getBlood());
        return patronsBattle;
    }

    public static List<DouLuoDaLuUserPatrons> parseUserPatrons(List<DouLuoDaLuProto.DouLuoDaLuPatronsDataTemp> allPatronsList) {
        List<DouLuoDaLuUserPatrons> result = new ArrayList<>();
        for (DouLuoDaLuProto.DouLuoDaLuPatronsDataTemp patronsDataTemp : allPatronsList) {
            DouLuoDaLuUserPatrons patrons  = new DouLuoDaLuUserPatrons();
            patrons.setPatronsId(patronsDataTemp.getPatronsId());
            patrons.setPatronsLv(patronsDataTemp.getPatronsLv());
            patrons.setAbility(patronsDataTemp.getAbility());
            patrons.setSkinId(patronsDataTemp.getSkinId());
            patrons.setPromotionId(patronsDataTemp.getPromotionId());
            patrons.setStageLv(patronsDataTemp.getStageLv());
            result.add(patrons);
        }
        return result;
    }

    public static DouLuoDaLuProto.DouLuoDaLuTryTrainRecordMsg.Builder parseTryTrainMsg(DouLuoDaLuTryTrainRecordData data) {
        DouLuoDaLuProto.DouLuoDaLuTryTrainRecordMsg.Builder builder = DouLuoDaLuProto.DouLuoDaLuTryTrainRecordMsg.newBuilder();
        builder.setUserId(data.getUserId());
        builder.setTime(data.getTime());
        builder.setGoodsId(data.getRewardId());
        builder.setPlayerMsg(PlayerBasePb.parsePlayerBaseTempMsg(data.getUserBaseInfo()));
        return builder;
    }

    public static List<DouLuoDaLuProto.DouLuoDaLuUserItemInfoTemp> parseUserItemTemp(Map<Integer, Integer> itemMap){
        List<DouLuoDaLuProto.DouLuoDaLuUserItemInfoTemp> result = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : itemMap.entrySet()) {
            if(entry.getValue() <= 0){
                continue;
            }
            result.add(parseUserItemTemp(entry.getKey(), entry.getValue()).build());
        }
        return result;
    }

    public static DouLuoDaLuProto.DouLuoDaLuUserItemInfoTemp.Builder parseUserItemTemp(int item, int num){
        DouLuoDaLuProto.DouLuoDaLuUserItemInfoTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuUserItemInfoTemp.newBuilder();
        builder.setItemId(item);
        builder.setNum(num);
        return builder;
    }


    public static DouLuoDaLuProto.DouLuoDaLuEventNoticeTemp.Builder getEventNoticeBuilder(DouLuoDaLuEventNoticeData noticeData) {
        DouLuoDaLuProto.DouLuoDaLuEventNoticeTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuEventNoticeTemp.newBuilder();
        builder.setPlayerInfo(PlayerBasePb.parsePlayerBaseTempMsg(noticeData.getUserBaseInfo()));
        builder.setEventType(noticeData.getType());
        builder.setRewards(noticeData.getRewards());
        builder.setConsume(noticeData.getConsume());
        builder.setMonsterId(noticeData.getMonsterId());
        builder.addAllParams(noticeData.getParamList());
        builder.setUserId(noticeData.getUserId());
        builder.setEventId(noticeData.getEventId());
        builder.setAttackType(noticeData.getAttackType());
        if(noticeData.getEnemyBaseInfo() != null){
            builder.setEnemyInfo(PlayerBasePb.parsePlayerBaseTempMsg(noticeData.getEnemyBaseInfo()));
        }
        if(noticeData.getFriendBaseInfo() != null){
            builder.setFriend(PlayerBasePb.parsePlayerBaseTempMsg(noticeData.getFriendBaseInfo()));
        }
        return builder;
    }

    public static DouLuoDaLuProto.DouLuoDaLuBattleNoticeTemp.Builder getBattleNoticeBuilder(DouLuoDaLuBattleNoticeData noticeData) {
        DouLuoDaLuProto.DouLuoDaLuBattleNoticeTemp.Builder builder = DouLuoDaLuProto.DouLuoDaLuBattleNoticeTemp.newBuilder();
        builder.setPlayerInfo(PlayerBasePb.parsePlayerBaseTempMsg(noticeData.getUserBaseInfo()));
        builder.setUserId(noticeData.getUserId());
        builder.setPatronsId(noticeData.getPatronsId());
        builder.setPatronsNum(noticeData.getPatronsNum());
        builder.setAll(noticeData.isAllKill());
        builder.setLogTime(noticeData.getLogTime());
        builder.setBattleType(noticeData.getBattleType());
        if(noticeData.getEnemyBaseInfo() != null){
            builder.setEnemyInfo(PlayerBasePb.parsePlayerBaseTempMsg(noticeData.getEnemyBaseInfo()));
        }
        return builder;
    }

    public static DouLuoDaLuEventNoticeData  parseDouLuoDaLuEventNoticeData(DouLuoDaLuProto.DouLuoDaLuEventNoticeTemp temp){
        DouLuoDaLuEventNoticeData noticeData = new DouLuoDaLuEventNoticeData();
        noticeData.setType(temp.getEventType());
        noticeData.setRewards(temp.getRewards());
        noticeData.setConsume(temp.getConsume());
        noticeData.setMonsterId(temp.getMonsterId());
        noticeData.setParamList(temp.getParamsList());
        noticeData.setEventId(temp.getEventId());
        return noticeData;
    }

    public static DouLuoDaLuBattleReportData paresDouLuoDaLuBattleReportData(DouLuoDaLuProto.DouLuoDaLuBattleReportTemp report, long userId, int activityId) {
        DouLuoDaLuBattleReportData reportData = new DouLuoDaLuBattleReportData();
        reportData.setActivityId(activityId);
        reportData.setEnemyId(report.getEnemyId());
        reportData.setEnemyBaseInfo(PlayerBasePb.parseToUserBaseInfo(report.getEnemyInfo()));
        reportData.setPatronsId(report.getPatronsId());
        reportData.setPatronsNum(report.getPatronsNum());
        reportData.setScore(report.getScore());
        reportData.setUserId(report.getUserId());
        reportData.setEnemyId(report.getEnemyId());
        reportData.setLogTime(report.getLogTime());
        reportData.setBattleType(report.getBattleType());
        return reportData;
    }

    public static DouLuoDaLuEventDefendData paresDouLuoDaLuBattleReportData(DouLuoDaLuProto.DouLuoDaLuEventNoticeTemp notice, long userId, int activityId) {
        DouLuoDaLuEventDefendData defendData = new DouLuoDaLuEventDefendData();
        defendData.setActivityId(activityId);
        defendData.setUserId(notice.getUserId());
        if(notice.hasEnemyInfo()) {
            defendData.setEnemyBaseInfo(PlayerBasePb.parseToUserBaseInfo(notice.getEnemyInfo()));
        }
        if(notice.hasFriend()){
            defendData.setFriendBaseInfo(PlayerBasePb.parseToUserBaseInfo(notice.getFriend()));
        }
        defendData.setEventType(notice.getEventType());
        defendData.setRewards(notice.getRewards());
        defendData.setConsume(notice.getConsume());
        defendData.setMonsterId(notice.getMonsterId());
        defendData.setParamList(notice.getParamsList());
        defendData.setEventId(notice.getEventId());
        defendData.setAttackType(notice.getAttackType());
        return defendData;
    }

    public static DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood.Builder buildDouLuoDaLuBattlePatronsBlood(DouLuoDaLuPatronsBattleEnemy patronsBlood){
        DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood.Builder builder = DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood.newBuilder();
        builder.setPatronsId(patronsBlood.getPatronsId());
        builder.setTotalBlood(patronsBlood.getTotalBlood());
        builder.setBlood(patronsBlood.getBlood());
        return builder;
    }

    public static DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood.Builder buildDouLuoDaLuBattlePatronsBlood(PatronsBlood patronsBlood){
        DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood.Builder builder = DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood.newBuilder();
        builder.setPatronsId(patronsBlood.getPatronsId());
        builder.setTotalBlood(patronsBlood.getTotalBlood());
        builder.setBlood(patronsBlood.getBlood());
        return builder;
    }

    public static PatronsBlood parseDouLuoDaLuPatronsBlood(DouLuoDaLuProto.DouLuoDaLuBattlePatronsBlood patronsBlood){
        PatronsBlood patronsBattleEnemy = new PatronsBlood();
        patronsBattleEnemy.setPatronsId(patronsBlood.getPatronsId());
        patronsBattleEnemy.setTotalBlood(patronsBlood.getTotalBlood());
        patronsBattleEnemy.setBlood(patronsBlood.getBlood());
        return patronsBattleEnemy;
    }

    public static PatronsBlood parseDouLuoDaLuPatronsBlood(DouLuoDaLuPatronsBattleEnemy patronsBlood){
        PatronsBlood patronsBattleEnemy = new PatronsBlood();
        patronsBattleEnemy.setPatronsId(patronsBlood.getPatronsId());
        patronsBattleEnemy.setTotalBlood(patronsBlood.getTotalBlood());
        patronsBattleEnemy.setBlood(patronsBlood.getBlood());
        return patronsBattleEnemy;
    }

    public static DouLuoDaLuProto.DouLuoDaLuUserMallInfo.Builder parseDouLuoDaLuUserMallInfo(int mallId, int touchTime, int times){
        DouLuoDaLuProto.DouLuoDaLuUserMallInfo.Builder msg = DouLuoDaLuProto.DouLuoDaLuUserMallInfo.newBuilder();
        msg.setMallId(mallId);
        msg.setTouchTime(touchTime);
        msg.setCanBuyTimes(times);
        return msg;
    }
}
